﻿using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Linq;
using System.Web;
using UricaoWeb.Datos.ConexionBD.Menu;
using UricaoWeb.Datos.ConexionBD.Propiedad;
using System.Data.SqlClient;

using System.Windows.Forms;
using UricaoWeb.Datos.Excepciones.Menu;
using System.Web.UI;

namespace UricaoWeb.LogicaDeNegocios.Menu
{
    public class conexionBD
    {
        public static string _mensajeFinal;
        public const string _mensajeMenuExcepcion = "Error en la gestion menu ";
        public const string _mensajeReferencia = "Error, se hace referencia nula ";
        public const string _mensajeGeneral = "Error general ";


        ///<sumary>
        ///Metodo para modificar un plato
        ///Parámetros:
        ///idPlato: id del plato
        ///nombrePlato: nombre del plato
        ///precioPlato: precio del plato
        ///fotoPlato: ruta de la foto
        ///detallePlato: detalles del plato
        ///compartirPlato: si es un plato compartido o en caso contrario individual
        ///activoPlato: si el status del plati es activo
        ///Retorno: Entero que indica el numero de filas afectadas
        ///Excepeciones: 
        ///NullReferenceException: Toma el error si se hace referencia de un objeto nulo
        ///Exception: Toma el error general con clase MenuExcepciones
        ///</sumary>
        public int ActualizarPlato(int IdPlato, string nombrePlato, float precioPlato, string fotoPlato, string detallePlato, bool compartirPlato, bool activoPlato)
        {
            List<DbParameter> parametros = new List<DbParameter>();


            DbParameter param = datoMenu.dpf.CreateParameter();
            param.Value = IdPlato;
            param.ParameterName = "IdPlato";
            parametros.Add(param);

            DbParameter param1 = datoMenu.dpf.CreateParameter();
            param1.Value = nombrePlato;
            param1.ParameterName = "nombrePlato";
            parametros.Add(param1);

            DbParameter param2 = datoMenu.dpf.CreateParameter();
            param2.Value = precioPlato;
            param2.ParameterName = "precioPlato";
            parametros.Add(param2);

            DbParameter param3 = datoMenu.dpf.CreateParameter();
            param3.Value = fotoPlato;
            param3.ParameterName = "fotoPlato";
            parametros.Add(param3);

            DbParameter param4 = datoMenu.dpf.CreateParameter();
            param4.Value = detallePlato;
            param4.ParameterName = "detallePlato";
            parametros.Add(param4);

            DbParameter param5 = datoMenu.dpf.CreateParameter();
            if (compartirPlato == true)
                param5.Value = 1;
            else
                param5.Value = 0;
            param5.ParameterName = "compartirPlato";
            parametros.Add(param5);

            DbParameter param6 = datoMenu.dpf.CreateParameter();
            if (activoPlato == true)
                param6.Value = 1;
            else
                param6.Value = 0;
            param6.ParameterName = "activoPlato";
            parametros.Add(param6);
            try
            {
                return datoMenu.ejecutaNonQuery("[dbo].[ActualizarPlato]", parametros);
            }
            catch (MenuExcepciones e)
            {
                _mensajeFinal = _mensajeMenuExcepcion + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (NullReferenceException e)
            {
                _mensajeFinal = _mensajeReferencia + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (Exception e)
            {
                _mensajeFinal = _mensajeGeneral + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;

            }
            return 0;
        }

        ///<sumary>
        ///Metodo para insertar un plato
        ///Parámetros:
        ///nombrePlato: nombre del plato
        ///precioPlato: precio del plato
        ///fotoPlato: ruta de la foto
        ///detallePlato: detalles del plato
        ///compartirPlato: si es un plato compartido o en caso contrario individual
        ///activoPlato: si el status del plati es activo
        ///Retorno: Entero que indica el numero de filas afectadas
        ///Excepeciones: 
        ///NullReferenceException: Toma el error si se hace referencia de un objeto nulo
        ///Exception: Toma el error general con clase MenuExcepciones
        ///</sumary>
        public int InsertarPlato(string nombrePlato, float precioPlato, string fotoPlato, string detallePlato, bool compartirPlato, bool activoPlato)
        {
            List<DbParameter> parametros = new List<DbParameter>();

            DbParameter param1 = datoMenu.dpf.CreateParameter();
            param1.Value = nombrePlato;
            param1.ParameterName = "nombrePlato";
            parametros.Add(param1);

            DbParameter param2 = datoMenu.dpf.CreateParameter();
            param2.Value = precioPlato;
            param2.ParameterName = "precioPlato";
            parametros.Add(param2);

            DbParameter param3 = datoMenu.dpf.CreateParameter();
            param3.Value = fotoPlato;
            param3.ParameterName = "fotoPlato";
            parametros.Add(param3);

            DbParameter param4 = datoMenu.dpf.CreateParameter();
            param4.Value = detallePlato;
            param4.ParameterName = "detallePlato";
            parametros.Add(param4);

            DbParameter param5 = datoMenu.dpf.CreateParameter();
            if (compartirPlato == true)
                param5.Value = 1;
            else
                param5.Value = 0;
            param5.ParameterName = "compartirPlato";
            parametros.Add(param5);

            DbParameter param6 = datoMenu.dpf.CreateParameter();
            if (activoPlato == true)
                param6.Value = 1;
            else
                param6.Value = 0;
            param6.ParameterName = "activoPlato";
            parametros.Add(param6);
            try
            {
                return datoMenu.ejecutaNonQuery("[dbo].[AgregarPlato]", parametros);
            }
            catch (MenuExcepciones e)
            {
                _mensajeFinal = _mensajeMenuExcepcion + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (NullReferenceException e)
            {
                _mensajeFinal = _mensajeReferencia + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (Exception e)
            {
                _mensajeFinal = _mensajeGeneral + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;

            }
            return 0;
        }

        ///<sumary>
        ///Metodo para consultar TODOS los platos del sistema
        ///Parámetros:(no posee)
        ///Retorno: Lista del objeto Plato
        ///Excepeciones: 
        ///NullReferenceException: Toma el error si se hace referencia de un objeto nulo
        ///Exception: Toma el error general con clase MenuExcepciones
        ///</sumary>
        public List<Plato> ConsultarListaPlatos()
        {
            List<Plato> listaPlato = new List<Plato>();

            string StoredProcedure = "[dbo].[ObtenerPlato]";
            try
            {
                using (DbConnection con = datoMenu.dpf.CreateConnection())
                {
                    con.ConnectionString = datoMenu.constr;
                    using (DbCommand cmd = datoMenu.dpf.CreateCommand())
                    {
                        cmd.Connection = con;
                        cmd.CommandText = StoredProcedure;
                        cmd.CommandType = CommandType.StoredProcedure;
                        con.Open();
                        using (DbDataReader dr = cmd.ExecuteReader())
                        {
                            while (dr.Read())
                            {
                                listaPlato.Add(new Plato(int.Parse(dr["IdPlato"].ToString()), dr["nombrePlato"].ToString(), float.Parse(dr["precioPlato"].ToString()), dr["fotoPlato"].ToString(), dr["detallePlato"].ToString(), bool.Parse(dr["compartirPlato"].ToString()), bool.Parse(dr["activoPlato"].ToString())));
                            }
                        }
                    }
                }
            }
            catch (MenuExcepciones e)
            {
                _mensajeFinal = _mensajeMenuExcepcion + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (NullReferenceException e)
            {
                _mensajeFinal = _mensajeReferencia + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (Exception e)
            {
                _mensajeFinal = _mensajeGeneral + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;

            }
            return listaPlato;
        }

        ///<sumary>
        ///Metodo para consultar la informacion de UN plato
        ///Parámetros:
        ///idPlato: id del plato
        ///Retorno: objeto Plato
        ///Excepeciones: 
        ///NullReferenceException: Toma el error si se hace referencia de un objeto nulo
        ///Exception: Toma el error general con clase MenuExcepciones
        ///</sumary>
        public Plato ConsultarPlatoconId(int IdPlato)
        {
            Plato objPlato = new Plato();
            string StoredProcedure = "[dbo].[ObtenerPlatobyID]";
            try
            {
                using (DbConnection con = datoMenu.dpf.CreateConnection())
                {
                    con.ConnectionString = datoMenu.constr;
                    using (DbCommand cmd = datoMenu.dpf.CreateCommand())
                    {
                        cmd.Connection = con;
                        cmd.CommandText = StoredProcedure;
                        cmd.CommandType = CommandType.StoredProcedure;
                        DbParameter param = cmd.CreateParameter();
                        param.DbType = DbType.Int32;
                        param.ParameterName = "IdPlato";
                        param.Value = IdPlato;
                        cmd.Parameters.Add(param);
                        con.Open();
                        using (DbDataReader dr = cmd.ExecuteReader())
                        {
                            if (dr.Read())
                            {
                                objPlato = new Plato(IdPlato, dr["nombrePlato"].ToString(), float.Parse(dr["precioPlato"].ToString()), dr["fotoPlato"].ToString(), dr["detallePlato"].ToString(), bool.Parse(dr["compartirPlato"].ToString()), bool.Parse(dr["activoPlato"].ToString()));
                            }
                        }
                    }
                }
            }
            catch (MenuExcepciones e)
            {
                _mensajeFinal = _mensajeMenuExcepcion + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (NullReferenceException e)
            {
                _mensajeFinal = _mensajeReferencia + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (Exception e)
            {
                _mensajeFinal = _mensajeGeneral + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;

            }
            return objPlato;
        }


        //<sumary>
        ///Metodo para insertar un menu
        ///Parámetros:
        ///nombreMenu: nombre del menu
        ///tipoMenu: tipo del menu (si son platos fuertes, entradas, postres)
        ///activoMenu: status del menu (activo desactivo)
        ///fkRestaurante: foranea de restaurante
        ///Retorno: entero que devuelve el numero de filas implicadas
        ///Excepeciones: 
        ///NullReferenceException: Toma el error si se hace referencia de un objeto nulo
        ///Exception: Toma el error general con clase MenuExcepciones
        ///</sumary>
        public int InsertarMenu(string nombreMenu, string tipoMenu, bool activoMenu, int fkRestaurante)
        {
            List<DbParameter> parametros = new List<DbParameter>();

            DbParameter param1 = datoMenu.dpf.CreateParameter();
            param1.Value = nombreMenu;
            param1.ParameterName = "nombreMenu";
            parametros.Add(param1);

            DbParameter param2 = datoMenu.dpf.CreateParameter();
            param2.Value = tipoMenu;
            param2.ParameterName = "tipoMenu";
            parametros.Add(param2);

            DbParameter param3 = datoMenu.dpf.CreateParameter();
            if (activoMenu == true)
                param3.Value = 1;
            else
                param3.Value = 0;
            param3.ParameterName = "activoMenu";
            parametros.Add(param3);

            DbParameter param4 = datoMenu.dpf.CreateParameter();
            param4.Value = fkRestaurante;
            param4.ParameterName = "fkRestaurante";
            parametros.Add(param4);

            try
            {
                return datoMenu.ejecutaNonQuery("[dbo].[AgregarMenu]", parametros);
            }
            catch (MenuExcepciones e)
            {
                _mensajeFinal = _mensajeMenuExcepcion + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (NullReferenceException e)
            {
                _mensajeFinal = _mensajeReferencia + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (Exception e)
            {
                _mensajeFinal = _mensajeGeneral + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;

            }
            return 0;
        }

        ///<sumary>
        ///Metodo para consultar TODOS los Menu del sistema
        ///Parámetros: (no posee)
        ///Retorno: Lista de objetos de tipo Menu
        ///Excepeciones: 
        ///NullReferenceException: Toma el error si se hace referencia de un objeto nulo
        ///Exception: Toma el error general con clase MenuExcepciones
        ///</sumary>
        public List<Menu> ConsultarListaMenu()
        {
            List<Menu> listaMenu = new List<Menu>();

            string StoredProcedure = "[dbo].[ObtenerMenu]";
            try
            {
                using (DbConnection con = datoMenu.dpf.CreateConnection())
                {
                    con.ConnectionString = datoMenu.constr;
                    using (DbCommand cmd = datoMenu.dpf.CreateCommand())
                    {
                        cmd.Connection = con;
                        cmd.CommandText = StoredProcedure;
                        cmd.CommandType = CommandType.StoredProcedure;
                        con.Open();
                        using (DbDataReader dr = cmd.ExecuteReader())
                        {
                            while (dr.Read())
                            {
                                listaMenu.Add(new Menu((int)dr["IdMenu"], (string)dr["nombreMenu"], (string)dr["tipoMenu"], (bool)dr["activoMenu"], (int)dr["fkRestaurante"]));
                            }
                        }
                    }
                }
            }
            catch (MenuExcepciones e)
            {
                _mensajeFinal = _mensajeMenuExcepcion + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (NullReferenceException e)
            {
                _mensajeFinal = _mensajeReferencia + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (Exception e)
            {
                _mensajeFinal = _mensajeGeneral + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;

            }
            return listaMenu;
        }


        ///<sumary>
        ///Metodo para consultar la informacion de UN menu
        ///Parámetros:
        ///idMEnu: id del menu
        ///Retorno: Objeto Menu
        ///Excepeciones: 
        ///NullReferenceException: Toma el error si se hace referencia de un objeto nulo
        ///Exception: Toma el error general con clase MenuExcepciones
        ///</sumary>
        public Menu ConsultarMenuConId(int IdMenu)
        {
            Menu objMenu = new Menu();
            string StoredProcedure = "[dbo].[ObtenerMenubyID]";
            try
            {
                using (DbConnection con = datoMenu.dpf.CreateConnection())
                {
                    con.ConnectionString = datoMenu.constr;
                    using (DbCommand cmd = datoMenu.dpf.CreateCommand())
                    {
                        cmd.Connection = con;
                        cmd.CommandText = StoredProcedure;
                        cmd.CommandType = CommandType.StoredProcedure;
                        DbParameter param = cmd.CreateParameter();
                        param.DbType = DbType.Int32;
                        param.ParameterName = "IdMenu";
                        param.Value = IdMenu;
                        cmd.Parameters.Add(param);
                        con.Open();
                        using (DbDataReader dr = cmd.ExecuteReader())
                        {
                            if (dr.Read())
                            {
                                objMenu = new Menu(IdMenu, (string)dr["nombreMenu"], (string)dr["tipoMenu"], (bool)dr["activoMenu"], (int)dr["fkRestaurante"]);
                            }
                        }
                    }
                }

            }
            catch (MenuExcepciones e)
            {
                _mensajeFinal = _mensajeMenuExcepcion + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (NullReferenceException e)
            {
                _mensajeFinal = _mensajeReferencia + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (Exception e)
            {
                _mensajeFinal = _mensajeGeneral + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;

            }
            return objMenu;
        }

        ///<sumary>
        ///Metodo para consultar la informacion de UN menu
        ///Parámetros:
        ///idMEnu: id del menu
        ///Retorno: Objeto Menu
        ///Excepeciones: 
        ///NullReferenceException: Toma el error si se hace referencia de un objeto nulo
        ///Exception: Toma el error general con clase MenuExcepciones
        ///</sumary>
        public List<Menu> ConsultarMenuPorRestaurante(int fkRestaurante)
        {
            List<Menu> listaMenu = new List<Menu>();
            string StoredProcedure = "[dbo].[ObtenerMenubyFKRestaurante]";
            try
            {
                using (DbConnection con = datoMenu.dpf.CreateConnection())
                {
                    con.ConnectionString = datoMenu.constr;
                    using (DbCommand cmd = datoMenu.dpf.CreateCommand())
                    {
                        cmd.Connection = con;
                        cmd.CommandText = StoredProcedure;
                        cmd.CommandType = CommandType.StoredProcedure;
                        DbParameter param = cmd.CreateParameter();
                        param.DbType = DbType.Int32;
                        param.ParameterName = "fkRestaurante";
                        param.Value = fkRestaurante;
                        cmd.Parameters.Add(param);
                        con.Open();
                        using (DbDataReader dr = cmd.ExecuteReader())
                        {
                            while (dr.Read())
                            {
                                listaMenu.Add(new Menu((int)dr["IdMenu"], (string)dr["nombreMenu"], (string)dr["tipoMenu"], (bool)dr["activoMenu"], (int)dr["fkRestaurante"]));
                            }
                        }
                    }
                }

            }
            catch (MenuExcepciones e)
            {
                _mensajeFinal = _mensajeMenuExcepcion + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (NullReferenceException e)
            {
                _mensajeFinal = _mensajeReferencia + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (Exception e)
            {
                _mensajeFinal = _mensajeGeneral + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;

            }
            return listaMenu;
        }


        ///<sumary>
        ///Metodo para modificar un menu
        ///Parámetros:
        ///IdMenu: id del plato
        ///nombreMenu: nombre del plato
        ///tipoMenu: precio del plato
        ///activoMenu: ruta de la foto
        ///fkRestaurante: detalles del plato
        ///Retorno: Entero que indica el numero de filas afectadas
        ///Excepeciones: 
        ///MenuExcepciones: Toma el error general con clase MenuExcepciones
        ///Exception: Toma el error general con clase MenuExcepciones
        ///</sumary>
        public int ActualizarMenu(int IdMenu, string nombreMenu, string tipoMenu, bool activoMenu, int fkRestaurante)
        {
            List<DbParameter> parametros = new List<DbParameter>();

            DbParameter param = datoMenu.dpf.CreateParameter();
            param.Value = IdMenu;
            param.ParameterName = "IdMenu";
            parametros.Add(param);

            DbParameter param1 = datoMenu.dpf.CreateParameter();
            param1.Value = nombreMenu;
            param1.ParameterName = "nombreMenu";
            parametros.Add(param1);

            DbParameter param2 = datoMenu.dpf.CreateParameter();
            param2.Value = tipoMenu;
            param2.ParameterName = "tipoMenu";
            parametros.Add(param2);

            DbParameter param3 = datoMenu.dpf.CreateParameter();
            if (activoMenu == true)
                param3.Value = 1;
            else
                param3.Value = 0;
            param3.ParameterName = "activoMenu";
            parametros.Add(param3);

            DbParameter param4 = datoMenu.dpf.CreateParameter();
            param4.Value = fkRestaurante;
            param4.ParameterName = "fkRestaurante";
            parametros.Add(param4);
            try
            {
                return datoMenu.ejecutaNonQuery("[dbo].[ActualizarMenu]", parametros);
            }
            catch (MenuExcepciones e)
            {
                _mensajeFinal = _mensajeMenuExcepcion + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (NullReferenceException e)
            {
                _mensajeFinal = _mensajeReferencia + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (Exception e)
            {
                _mensajeFinal = _mensajeGeneral + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;

            }
            return 0;
        }

        ///<sumary>
        ///Metodo para insertar un menu_Plato
        ///Parámetros:
        ///fkMenu: foranea de menu
        ///fkPlato: foranea de plato
        ///Retorno: Entero que indica el numero de filas afectadas
        ///Excepeciones: 
        ///MenuExcepciones: Toma el error general con clase MenuExcepciones
        ///Exception: Toma el error general con clase MenuExcepciones
        ///</sumary>
        public int InsertarMenu_Plato(int fkMenu, int fkPlato)
        {
            List<DbParameter> parametros = new List<DbParameter>();

            DbParameter param = datoMenu.dpf.CreateParameter();
            param.Value = fkMenu;
            param.ParameterName = "fkMenu";
            parametros.Add(param);

            DbParameter param1 = datoMenu.dpf.CreateParameter();
            param1.Value = fkPlato;
            param1.ParameterName = "fkPlato";
            parametros.Add(param1);

            try
            {
                return datoMenu.ejecutaNonQuery("[dbo].[AgregarMen_Pla]", parametros);
            }
            catch (MenuExcepciones e)
            {
                _mensajeFinal = _mensajeMenuExcepcion + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (NullReferenceException e)
            {
                _mensajeFinal = _mensajeReferencia + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (Exception e)
            {
                _mensajeFinal = _mensajeGeneral + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;

            }
            return 0;
        }

        ///<sumary>
        ///Metodo para consultar la lista de los Men_Pla (menus y platos)
        ///Parámetros:
        ///Retorno: Lista de Menu y platos.
        ///Excepeciones: 
        ///Exception: 
        ///MenuExcepciones: Toma el error general con clase MenuExcepciones
        ///Exception: Toma el error general con clase MenuExcepciones
        ///</sumary>
        public List<Men_Pla> ConsultarListaMen_Pla()
        {
            List<Men_Pla> listaMen_Pla = new List<Men_Pla>();

            string StoredProcedure = "[dbo].[ObtenerMen_Pla]";
            try
            {
                using (DbConnection con = datoMenu.dpf.CreateConnection())
                {
                    con.ConnectionString = datoMenu.constr;
                    using (DbCommand cmd = datoMenu.dpf.CreateCommand())
                    {
                        cmd.Connection = con;
                        cmd.CommandText = StoredProcedure;
                        cmd.CommandType = CommandType.StoredProcedure;
                        con.Open();
                        using (DbDataReader dr = cmd.ExecuteReader())
                        {
                            while (dr.Read())
                            {
                                listaMen_Pla.Add(new Men_Pla((int)dr["fkMenu"], (int)dr["fkPlato"]));
                            }
                        }
                    }
                }
            }
            catch (MenuExcepciones e)
            {
                _mensajeFinal = _mensajeMenuExcepcion + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (NullReferenceException e)
            {
                _mensajeFinal = _mensajeReferencia + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (Exception e)
            {
                _mensajeFinal = _mensajeGeneral + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;

            }
            return listaMen_Pla;
        }

        ///<sumary>
        ///Metodo para consultar los Men_Pla dado un menu (todos los platos que pertenecen a un menu)
        ///Parámetros:
        ///fkMenu: foranea de menu
        ///Excepeciones: 
        ///MenuExcepciones: Toma el error general con clase MenuExcepciones
        ///Exception: Toma el error general con clase MenuExcepciones
        ///</sumary>
        public List<Men_Pla> ConsultarMen_PlaConIdMenu(int fkMenu)
        {
            List<Men_Pla> objMen_Pla = new List<Men_Pla>();
            string StoredProcedure = "[dbo].[ObtenerMen_PlabyMenu]";
            try
            {
                using (DbConnection con = datoMenu.dpf.CreateConnection())
                {
                    con.ConnectionString = datoMenu.constr;
                    using (DbCommand cmd = datoMenu.dpf.CreateCommand())
                    {
                        cmd.Connection = con;
                        cmd.CommandText = StoredProcedure;
                        cmd.CommandType = CommandType.StoredProcedure;
                        DbParameter param = cmd.CreateParameter();
                        param.DbType = DbType.Int32;
                        param.ParameterName = "fkMenu";
                        param.Value = fkMenu;
                        cmd.Parameters.Add(param);
                        con.Open();
                        using (DbDataReader dr = cmd.ExecuteReader())
                        {
                            while (dr.Read())
                            {
                                objMen_Pla.Add(new Men_Pla((int)dr["fkMenu"], (int)dr["fkPlato"]));
                            }
                        }
                    }
                }
            }
            catch (MenuExcepciones e)
            {
                _mensajeFinal = _mensajeMenuExcepcion + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (NullReferenceException e)
            {
                _mensajeFinal = _mensajeReferencia + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (Exception e)
            {
                _mensajeFinal = _mensajeGeneral + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;

            }
            return objMen_Pla;
        }

        ///<sumary>
        ///Metodo para consultar los Men_Pla dado un plato (todos los platos que pertenecen a un menu)
        ///Parámetros:
        ///fkPlato: foranea de plato
        ///Excepeciones: 
        ///MenuExcepciones: Toma el error general con clase MenuExcepciones
        ///Exception: Toma el error general con clase MenuExcepciones
        ///</sumary>
        public Men_Pla ConsultarMen_PlaConIdPlato(int fkPlato)
        {
            Men_Pla objMen_Pla = new Men_Pla();
            string StoredProcedure = "[dbo].[ObtenerMen_PlabyPlato]";
            try
            {
                using (DbConnection con = datoMenu.dpf.CreateConnection())
                {
                    con.ConnectionString = datoMenu.constr;
                    using (DbCommand cmd = datoMenu.dpf.CreateCommand())
                    {
                        cmd.Connection = con;
                        cmd.CommandText = StoredProcedure;
                        cmd.CommandType = CommandType.StoredProcedure;
                        DbParameter param = cmd.CreateParameter();
                        param.DbType = DbType.Int32;
                        param.ParameterName = "IdMenu";
                        param.Value = fkPlato;
                        cmd.Parameters.Add(param);
                        con.Open();
                        using (DbDataReader dr = cmd.ExecuteReader())
                        {
                            if (dr.Read())
                            {
                                objMen_Pla = new Men_Pla(fkPlato, (int)dr["fkPlato"]);
                            }
                        }
                    }
                }
            }
            catch (MenuExcepciones e)
            {
                _mensajeFinal = _mensajeMenuExcepcion + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (NullReferenceException e)
            {
                _mensajeFinal = _mensajeReferencia + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (Exception e)
            {
                _mensajeFinal = _mensajeGeneral + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;

            }
            return objMen_Pla;
        }

        ///<sumary>
        ///Metodo para actualizar Men_Pla 
        ///Parámetros:
        ///fkMenu: foranea de menu
        ///fkPlato: foranea de plato
        ///Excepeciones: 
        ///MenuExcepciones: Toma el error general con clase MenuExcepciones
        ///Exception: Toma el error general con clase MenuExcepciones
        ///</sumary>
        public int ActualizarMenu_Plato(int fkMenu, int fkPlato)
        {
            List<DbParameter> parametros = new List<DbParameter>();

            DbParameter param = datoMenu.dpf.CreateParameter();
            param.Value = fkMenu;
            param.ParameterName = "fkMenu";
            parametros.Add(param);

            DbParameter param1 = datoMenu.dpf.CreateParameter();
            param1.Value = fkPlato;
            param1.ParameterName = "fkPlato";
            parametros.Add(param1);
            try
            {
                return datoMenu.ejecutaNonQuery("[dbo].[ActualizarMen_Pla]", parametros);
            }
            catch (MenuExcepciones e)
            {
                _mensajeFinal = _mensajeMenuExcepcion + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (NullReferenceException e)
            {
                _mensajeFinal = _mensajeReferencia + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (Exception e)
            {
                _mensajeFinal = _mensajeGeneral + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;

            }
            return 0;
        }

        ///<sumary>
        ///Metodo para consultar un menu por su nombre
        ///Parámetros:
        ///nombreMenu: cadena que contiene el nombre de menu para realizar la busqueda
        ///Excepeciones: 
        ///MenuExcepciones: Toma el error general con clase MenuExcepciones
        ///Exception: Toma el error general con clase MenuExcepciones
        ///</sumary>
        public Menu ConsultarMenuConNombre(string nombreMenu)
        {
            Menu objMenu = new Menu();
            string StoredProcedure = "[dbo].[ObtenerMenubyNombre]";
            try
            {
                using (DbConnection con = datoMenu.dpf.CreateConnection())
                {
                    con.ConnectionString = datoMenu.constr;
                    using (DbCommand cmd = datoMenu.dpf.CreateCommand())
                    {
                        cmd.Connection = con;
                        cmd.CommandText = StoredProcedure;
                        cmd.CommandType = CommandType.StoredProcedure;
                        DbParameter param = cmd.CreateParameter();
                        param.DbType = DbType.String;
                        param.ParameterName = "nombreMenu";
                        param.Value = nombreMenu;
                        cmd.Parameters.Add(param);
                        con.Open();
                        using (DbDataReader dr = cmd.ExecuteReader())
                        {
                            if (dr.Read())
                            {
                                objMenu = new Menu((int)dr["IdMenu"], (string)nombreMenu, (string)dr["tipoMenu"], (bool)dr["activoMenu"], (int)dr["fkRestaurante"]);
                            }
                        }
                    }
                }
            }
            catch (MenuExcepciones e)
            {
                _mensajeFinal = _mensajeMenuExcepcion + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (NullReferenceException e)
            {
                _mensajeFinal = _mensajeReferencia + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (Exception e)
            {
                _mensajeFinal = _mensajeGeneral + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;

            }
            return objMenu;
        }

        ///<sumary>
        ///Metodo para consultar un plato por su nombre
        ///Parámetros:
        ///nombrePlato: cadena que contiene el nombre de plato para realizar la busqueda
        ///Excepeciones: 
        ///MenuExcepciones: Toma el error general con clase MenuExcepciones
        ///Exception: Toma el error general con clase MenuExcepciones
        ///</sumary>
        public Plato ConsultarPlatoconNombre(string nombrePlato)
        {
            Plato objPlato = new Plato();
            string StoredProcedure = "[dbo].[ObtenerPlatobyNombre]";
            try
            {
                using (DbConnection con = datoMenu.dpf.CreateConnection())
                {
                    con.ConnectionString = datoMenu.constr;
                    using (DbCommand cmd = datoMenu.dpf.CreateCommand())
                    {
                        cmd.Connection = con;
                        cmd.CommandText = StoredProcedure;
                        cmd.CommandType = CommandType.StoredProcedure;
                        DbParameter param = cmd.CreateParameter();
                        param.DbType = DbType.String;
                        param.ParameterName = "nombrePlato";
                        param.Value = nombrePlato;
                        cmd.Parameters.Add(param);
                        con.Open();
                        using (DbDataReader dr = cmd.ExecuteReader())
                        {
                            if (dr.Read())
                            {
                                objPlato = new Plato((int)dr["IdPlato"], nombrePlato, float.Parse(dr["precioPlato"].ToString()), dr["fotoPlato"].ToString(), dr["detallePlato"].ToString(), bool.Parse(dr["compartirPlato"].ToString()), bool.Parse(dr["activoPlato"].ToString()));
                            }
                        }
                    }
                }
            }
            catch (MenuExcepciones e)
            {
                _mensajeFinal = _mensajeMenuExcepcion + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (NullReferenceException e)
            {
                _mensajeFinal = _mensajeReferencia + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (Exception e)
            {
                _mensajeFinal = _mensajeGeneral + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;

            }
            return objPlato;
        }

        ///<sumary>
        ///Metodo para eliminar un Men_Pla dada una foranea de menu
        ///Parámetros:
        ///fkMenu: foranea de menu
        ///Excepeciones: 
        ///MenuExcepciones: Toma el error general con clase MenuExcepciones
        ///Exception: Toma el error general con clase MenuExcepciones
        ///</sumary>
        public void EliminarMenu_PlatoConMenu(int fkMenu)
        {
            List<Men_Pla> objMen_Pla = new List<Men_Pla>();
            string StoredProcedure = "[dbo].[EliminarMenPlaByMenu]";

            try
            {
                using (DbConnection con = datoMenu.dpf.CreateConnection())
                {
                    con.ConnectionString = datoMenu.constr;
                    using (DbCommand cmd = datoMenu.dpf.CreateCommand())
                    {
                        cmd.Connection = con;
                        cmd.CommandText = StoredProcedure;
                        cmd.CommandType = CommandType.StoredProcedure;
                        DbParameter param = cmd.CreateParameter();
                        param.DbType = DbType.Int32;
                        param.ParameterName = "fkMenu";
                        param.Value = fkMenu;
                        cmd.Parameters.Add(param);
                        con.Open();
                        using (DbDataReader dr = cmd.ExecuteReader())
                        {
                            while (dr.Read())
                            {
                                objMen_Pla.Add(new Men_Pla((int)dr["fkMenu"], (int)dr["fkPlato"]));
                            }
                        }
                    }
                }
            }
            catch (MenuExcepciones e)
            {
                _mensajeFinal = _mensajeMenuExcepcion + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (NullReferenceException e)
            {
                _mensajeFinal = _mensajeReferencia + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (Exception e)
            {
                _mensajeFinal = _mensajeGeneral + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;

            }
        }

        ///<sumary>
        ///Metodo para consultar los Hoteles del sistema
        ///Parámetros:(no posee)
        ///Excepeciones: 
        ///MenuExcepciones: Toma el error general con clase MenuExcepciones
        ///Exception: Toma el error general con clase MenuExcepciones
        ///</sumary>
        public List<Hotel> ConsultarListaHoteles()
        {
            List<Hotel> listaHotel = new List<Hotel>();

            string StoredProcedure = "[dbo].[ObtenerHoteles]";
            try
            {
                using (DbConnection con = datoMenu.dpf.CreateConnection())
                {
                    con.ConnectionString = datoMenu.constr;
                    using (DbCommand cmd = datoMenu.dpf.CreateCommand())
                    {
                        cmd.Connection = con;
                        cmd.CommandText = StoredProcedure;
                        cmd.CommandType = CommandType.StoredProcedure;
                        con.Open();
                        using (DbDataReader dr = cmd.ExecuteReader())
                        {
                            while (dr.Read())
                            {
                                listaHotel.Add(new Hotel(int.Parse(dr["IdHotel"].ToString()), dr["nombreHotel"].ToString(), dr["descripcionHotel"].ToString(), long.Parse(dr["telefonoHotel"].ToString()), dr["estrellaHotel"].ToString(), dr["direccionHotel"].ToString(), dr["fotoHotel"].ToString(), dr["monedaHotel"].ToString()));
                            }
                        }
                    }
                }
            }
            catch (MenuExcepciones e)
            {
                _mensajeFinal = _mensajeMenuExcepcion + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (NullReferenceException e)
            {
                _mensajeFinal = _mensajeReferencia + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;
            }
            catch (Exception e)
            {
                _mensajeFinal = _mensajeGeneral + Datos.ConexionBD.Menu.datoMenu._mensajeErrorBD;

            }
            return listaHotel;
        }
    }
}
